home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / distutils / command / build_py.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2005-10-18  |  11KB  |  338 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. """distutils.command.build_py
  5.  
  6. Implements the Distutils 'build_py' command."""
  7. __revision__ = '$Id: build_py.py,v 1.46 2004/11/10 22:23:15 loewis Exp $'
  8. import sys
  9. import string
  10. import os
  11. from types import *
  12. from glob import glob
  13. from distutils.core import Command
  14. from distutils.errors import *
  15. from distutils.util import convert_path
  16. from distutils import log
  17.  
  18. class build_py(Command):
  19.     description = '"build" pure Python modules (copy to build directory)'
  20.     user_options = [
  21.         ('build-lib=', 'd', 'directory to "build" (copy) to'),
  22.         ('compile', 'c', 'compile .py to .pyc'),
  23.         ('no-compile', None, "don't compile .py files [default]"),
  24.         ('optimize=', 'O', 'also compile with optimization: -O1 for "python -O", -O2 for "python -OO", and -O0 to disable [default: -O0]'),
  25.         ('force', 'f', 'forcibly build everything (ignore file timestamps)')]
  26.     boolean_options = [
  27.         'compile',
  28.         'force']
  29.     negative_opt = {
  30.         'no-compile': 'compile' }
  31.     
  32.     def initialize_options(self):
  33.         self.build_lib = None
  34.         self.py_modules = None
  35.         self.package = None
  36.         self.package_data = None
  37.         self.package_dir = None
  38.         self.compile = 0
  39.         self.optimize = 0
  40.         self.force = None
  41.  
  42.     
  43.     def finalize_options(self):
  44.         self.set_undefined_options('build', ('build_lib', 'build_lib'), ('force', 'force'))
  45.         self.packages = self.distribution.packages
  46.         self.py_modules = self.distribution.py_modules
  47.         self.package_data = self.distribution.package_data
  48.         self.package_dir = { }
  49.         if self.distribution.package_dir:
  50.             for name, path in self.distribution.package_dir.items():
  51.                 self.package_dir[name] = convert_path(path)
  52.             
  53.         
  54.         self.data_files = self.get_data_files()
  55.         if type(self.optimize) is not IntType:
  56.             
  57.             try:
  58.                 self.optimize = int(self.optimize)
  59.                 if self.optimize <= self.optimize:
  60.                     pass
  61.                 elif not self.optimize <= 2:
  62.                     raise AssertionError
  63.             except (ValueError, AssertionError):
  64.                 raise DistutilsOptionError, 'optimize must be 0, 1, or 2'
  65.             except:
  66.                 None<EXCEPTION MATCH>(ValueError, AssertionError)
  67.             
  68.  
  69.         None<EXCEPTION MATCH>(ValueError, AssertionError)
  70.  
  71.     
  72.     def run(self):
  73.         if self.py_modules:
  74.             self.build_modules()
  75.         
  76.         if self.packages:
  77.             self.build_packages()
  78.             self.build_package_data()
  79.         
  80.         self.byte_compile(self.get_outputs(include_bytecode = 0))
  81.  
  82.     
  83.     def get_data_files(self):
  84.         """Generate list of '(package,src_dir,build_dir,filenames)' tuples"""
  85.         data = []
  86.         if not self.packages:
  87.             return data
  88.         
  89.         for package in self.packages:
  90.             src_dir = self.get_package_dir(package)
  91.             build_dir = os.path.join(*[
  92.                 self.build_lib] + package.split('.'))
  93.             plen = len(src_dir) + 1
  94.             filenames = [ file[plen:] for file in self.find_data_files(package, src_dir) ]
  95.             data.append((package, src_dir, build_dir, filenames))
  96.         
  97.         return data
  98.  
  99.     
  100.     def find_data_files(self, package, src_dir):
  101.         """Return filenames for package's data files in 'src_dir'"""
  102.         globs = self.package_data.get('', []) + self.package_data.get(package, [])
  103.         files = []
  104.         for pattern in globs:
  105.             filelist = glob(os.path.join(src_dir, convert_path(pattern)))
  106.             [](_[1])
  107.         
  108.         return files
  109.  
  110.     
  111.     def build_package_data(self):
  112.         '''Copy data files into build directory'''
  113.         lastdir = None
  114.         for package, src_dir, build_dir, filenames in self.data_files:
  115.             for filename in filenames:
  116.                 target = os.path.join(build_dir, filename)
  117.                 self.mkpath(os.path.dirname(target))
  118.                 self.copy_file(os.path.join(src_dir, filename), target, preserve_mode = False)
  119.             
  120.         
  121.  
  122.     
  123.     def get_package_dir(self, package):
  124.         """Return the directory, relative to the top of the source
  125.            distribution, where package 'package' should be found
  126.            (at least according to the 'package_dir' option, if any)."""
  127.         path = string.split(package, '.')
  128.         if not self.package_dir:
  129.             if path:
  130.                 return apply(os.path.join, path)
  131.             else:
  132.                 return ''
  133.         else:
  134.             tail = []
  135.             while path:
  136.                 
  137.                 try:
  138.                     pdir = self.package_dir[string.join(path, '.')]
  139.                 except KeyError:
  140.                     tail.insert(0, path[-1])
  141.                     del path[-1]
  142.                     continue
  143.  
  144.                 tail.insert(0, pdir)
  145.                 return apply(os.path.join, tail)
  146.             pdir = self.package_dir.get('')
  147.             if pdir is not None:
  148.                 tail.insert(0, pdir)
  149.             
  150.             if tail:
  151.                 return apply(os.path.join, tail)
  152.             else:
  153.                 return ''
  154.  
  155.     
  156.     def check_package(self, package, package_dir):
  157.         if package_dir != '':
  158.             if not os.path.exists(package_dir):
  159.                 raise DistutilsFileError, "package directory '%s' does not exist" % package_dir
  160.             
  161.             if not os.path.isdir(package_dir):
  162.                 raise DistutilsFileError, ("supposed package directory '%s' exists, " + 'but is not a directory') % package_dir
  163.             
  164.         
  165.         if package:
  166.             init_py = os.path.join(package_dir, '__init__.py')
  167.             if os.path.isfile(init_py):
  168.                 return init_py
  169.             else:
  170.                 log.warn("package init file '%s' not found " + '(or not a regular file)', init_py)
  171.         
  172.  
  173.     
  174.     def check_module(self, module, module_file):
  175.         if not os.path.isfile(module_file):
  176.             log.warn('file %s (for module %s) not found', module_file, module)
  177.             return 0
  178.         else:
  179.             return 1
  180.  
  181.     
  182.     def find_package_modules(self, package, package_dir):
  183.         self.check_package(package, package_dir)
  184.         module_files = glob(os.path.join(package_dir, '*.py'))
  185.         modules = []
  186.         setup_script = os.path.abspath(self.distribution.script_name)
  187.         for f in module_files:
  188.             abs_f = os.path.abspath(f)
  189.             if abs_f != setup_script:
  190.                 module = os.path.splitext(os.path.basename(f))[0]
  191.                 modules.append((package, module, f))
  192.                 continue
  193.             self.debug_print('excluding %s' % setup_script)
  194.         
  195.         return modules
  196.  
  197.     
  198.     def find_modules(self):
  199.         '''Finds individually-specified Python modules, ie. those listed by
  200.         module name in \'self.py_modules\'.  Returns a list of tuples (package,
  201.         module_base, filename): \'package\' is a tuple of the path through
  202.         package-space to the module; \'module_base\' is the bare (no
  203.         packages, no dots) module name, and \'filename\' is the path to the
  204.         ".py" file (relative to the distribution root) that implements the
  205.         module.
  206.         '''
  207.         packages = { }
  208.         modules = []
  209.         for module in self.py_modules:
  210.             path = string.split(module, '.')
  211.             package = string.join(path[0:-1], '.')
  212.             module_base = path[-1]
  213.             
  214.             try:
  215.                 (package_dir, checked) = packages[package]
  216.             except KeyError:
  217.                 package_dir = self.get_package_dir(package)
  218.                 checked = 0
  219.  
  220.             if not checked:
  221.                 init_py = self.check_package(package, package_dir)
  222.                 packages[package] = (package_dir, 1)
  223.                 if init_py:
  224.                     modules.append((package, '__init__', init_py))
  225.                 
  226.             
  227.             module_file = os.path.join(package_dir, module_base + '.py')
  228.             if not self.check_module(module, module_file):
  229.                 continue
  230.             
  231.             modules.append((package, module_base, module_file))
  232.         
  233.         return modules
  234.  
  235.     
  236.     def find_all_modules(self):
  237.         """Compute the list of all modules that will be built, whether
  238.         they are specified one-module-at-a-time ('self.py_modules') or
  239.         by whole packages ('self.packages').  Return a list of tuples
  240.         (package, module, module_file), just like 'find_modules()' and
  241.         'find_package_modules()' do."""
  242.         modules = []
  243.         if self.py_modules:
  244.             modules.extend(self.find_modules())
  245.         
  246.         if self.packages:
  247.             for package in self.packages:
  248.                 package_dir = self.get_package_dir(package)
  249.                 m = self.find_package_modules(package, package_dir)
  250.                 modules.extend(m)
  251.             
  252.         
  253.         return modules
  254.  
  255.     
  256.     def get_source_files(self):
  257.         modules = self.find_all_modules()
  258.         filenames = []
  259.         for module in modules:
  260.             filenames.append(module[-1])
  261.         
  262.         return filenames
  263.  
  264.     
  265.     def get_module_outfile(self, build_dir, package, module):
  266.         outfile_path = [
  267.             build_dir] + list(package) + [
  268.             module + '.py']
  269.         return apply(os.path.join, outfile_path)
  270.  
  271.     
  272.     def get_outputs(self, include_bytecode = 1):
  273.         modules = self.find_all_modules()
  274.         outputs = []
  275.         for package, module, module_file in modules:
  276.             package = string.split(package, '.')
  277.             filename = self.get_module_outfile(self.build_lib, package, module)
  278.             outputs.append(filename)
  279.             if include_bytecode:
  280.                 if self.compile:
  281.                     outputs.append(filename + 'c')
  282.                 
  283.                 if self.optimize > 0:
  284.                     outputs.append(filename + 'o')
  285.                 
  286.             self.optimize > 0
  287.         
  288.         [] += [ os.path.join(build_dir, filename) for package, src_dir, build_dir, filenames in self.data_files for filename in filenames ]
  289.         return outputs
  290.  
  291.     
  292.     def build_module(self, module, module_file, package):
  293.         if type(package) is StringType:
  294.             package = string.split(package, '.')
  295.         elif type(package) not in (ListType, TupleType):
  296.             raise TypeError, "'package' must be a string (dot-separated), list, or tuple"
  297.         
  298.         outfile = self.get_module_outfile(self.build_lib, package, module)
  299.         dir = os.path.dirname(outfile)
  300.         self.mkpath(dir)
  301.         return self.copy_file(module_file, outfile, preserve_mode = 0)
  302.  
  303.     
  304.     def build_modules(self):
  305.         modules = self.find_modules()
  306.         for package, module, module_file in modules:
  307.             self.build_module(module, module_file, package)
  308.         
  309.  
  310.     
  311.     def build_packages(self):
  312.         for package in self.packages:
  313.             package_dir = self.get_package_dir(package)
  314.             modules = self.find_package_modules(package, package_dir)
  315.             for package_, module, module_file in modules:
  316.                 if not package == package_:
  317.                     raise AssertionError
  318.                 self.build_module(module, module_file, package)
  319.             
  320.         
  321.  
  322.     
  323.     def byte_compile(self, files):
  324.         byte_compile = byte_compile
  325.         import distutils.util
  326.         prefix = self.build_lib
  327.         if prefix[-1] != os.sep:
  328.             prefix = prefix + os.sep
  329.         
  330.         if self.compile:
  331.             byte_compile(files, optimize = 0, force = self.force, prefix = prefix, dry_run = self.dry_run)
  332.         
  333.         if self.optimize > 0:
  334.             byte_compile(files, optimize = self.optimize, force = self.force, prefix = prefix, dry_run = self.dry_run)
  335.         
  336.  
  337.  
  338.